'use strict';

const Controller = require('egg').Controller;

/**
 * 人员管理控制器
 * 处理人员的增删改查、登录认证、统计等功能
 */
class PersonController extends Controller {
  /**
   * 获取人员列表
   * 支持按姓名和部门筛选，支持分页查询
   * @param {Object} ctx.request.body
   * @param {string} [ctx.request.body.person_name] - 人员姓名，模糊匹配
   * @param {number} [ctx.request.body.department_id] - 部门ID
   * @param {number} [ctx.request.body.page=1] - 页码
   * @param {number} [ctx.request.body.page_size=10] - 每页条数
   */
  async list() {
    const {
      ctx
    } = this;

    // 验证参数
    ctx.validate({
      person_name: {
        type: 'string',
        required: false
      },
      department_id: {
        type: 'number',
        required: false
      },
      page: {
        type: 'number',
        required: false,
        min: 1
      },
      page_size: {
        type: 'number',
        required: false,
        min: 1,
        max: 100
      }
    }, ctx.request.body);

    const result = await ctx.service.person.findAll(ctx.request.body);
    ctx.body = result;
  }

  /**
   * 获取单个人员信息
   * @param {Object} ctx.request.body
   * @param {number} ctx.request.body.person_id - 人员ID
   * @throws {404} 未找到该人员时抛出异常
   */
  async getById() {
    const {
      ctx
    } = this;
    const {
      person_id
    } = ctx.request.body;
    const person = await ctx.service.person.findById(person_id);
    if (!person) {
      ctx.throw(404, '未找到该人员');
    }
    ctx.body = person;
  }

  /**
   * 创建新人员
   * @param {Object} ctx.request.body
   * @param {string} ctx.request.body.person_name - 人员姓名
   * @param {number} ctx.request.body.position - 职位
   * @param {number} ctx.request.body.department_id - 部门ID
   * @param {string} ctx.request.body.password - 密码
   * @param {string} [ctx.request.body.phone_number] - 手机号
   * @param {string} [ctx.request.body.role_main='普通用户'] - 角色，可选值：普通用户、系统管理员
   * @param {string} [ctx.request.body.role='普通用户'] - 角色，可选值：普通用户、审核员、系统管理员
   * @param {string} [ctx.request.body.role_destination='普通用户'] - 角色，可选值：普通用户、部门负责人、系统管理员
   * @param {string} [ctx.request.body.role_ov='普通用户'] - 角色，可选值：普通用户、部门负责人、系统管理员
   */
  async create() {
    const {
      ctx
    } = this;
    ctx.validate({
      person_name: {
        type: 'string',
        required: true
      },
      position: {
        type: 'string',
        required: false
      },
      department_id: {
        type: 'number',
        required: true
      },
      // password: { type: 'string', required: true },
      phone_number: {
        type: 'string',
        required: true
      },
      role_main: {
        type: 'enum',
        values: ['普通用户', '系统管理员'],
        required: false
      },
      role: {
        type: 'enum',
        values: ['普通用户', '审核员', '系统管理员'],
        required: false
      },
      role_destination: {
        type: 'enum',
        values: ['普通用户', '部门负责人', '系统管理员'],
        required: false
      },
      role_ov: {
        type: 'enum',
        values: ['普通用户', '部门负责人', '系统管理员'],
        required: false
      },
    });
    const result = await ctx.service.person.create(ctx.request.body);
    ctx.body = result;
  }

  // 更新人员信息
  async update() {
    const {
      ctx
    } = this;
    ctx.validate({
      person_id: {
        type: 'number',
        required: true
      },
      person_name: {
        type: 'string',
        required: true
      },
      position: {
        type: 'string',
        required: false
      },
      department_id: {
        type: 'number',
        required: false
      },
      password: {
        type: 'string',
        required: false
      },
      phone_number: {
        type: 'string',
        required: false
      },
      role_main: {
        type: 'enum',
        values: ['普通用户', '系统管理员'],
        required: false
      },
      role: {
        type: 'enum',
        values: ['普通用户', , '审核员', '系统管理员'],
        required: false
      },
      role_destination: {
        type: 'enum',
        values: ['普通用户', , '部门负责人', '系统管理员'],
        required: false
      },
      role_ov: {
        type: 'enum',
        values: ['普通用户', , '部门负责人', '系统管理员'],
        required: false
      },
    });
    const result = await ctx.service.person.update(ctx.request.body.person_id, ctx.request.body);
    ctx.body = result;
  }

  // 更新人员启用状态
  async updateActived() {
    const {
      ctx
    } = this;
    ctx.validate({
      person_id: {
        type: 'number',
        required: true
      },
      is_actived: {
        type: 'enum',
        values: [0, 1],
        required: false
      },
    });
    const result = await ctx.service.person.updateActived(ctx.request.body.person_id, ctx.request.body);
    ctx.body = result;
  }

  // 重置密码
  async resetPassword() {
    const {
      ctx
    } = this;
    ctx.validate({
      person_id: {
        type: 'number',
        required: true
      },
    });
    const result = await ctx.service.person.resetPassword(ctx.request.body.person_id);
    ctx.body = result;
  }

  // 删除人员（软删除）
  async delete() {
    const {
      ctx
    } = this;
    const {
      person_id
    } = ctx.request.body;
    const result = await ctx.service.person.delete(person_id);
    if (!result) {
      ctx.throw(404, '未找到该人员');
    }
    ctx.body = result;
  }

  /**
   * 用户登录
   * 验证手机号和密码，生成JWT token
   */
  async login() {
    const {
      ctx,
      app
    } = this;
    // 验证请求参数
    ctx.validate({
      phone_number: {
        type: 'string',
        required: true
      },
      password: {
        type: 'string',
        required: true
      },
    });

    const {
      phone_number,
      password
    } = ctx.request.body;

    // 验证用户凭据
    const person = await ctx.service.person.findByPhoneAndPassword(phone_number, password);
    if (!person) {
      ctx.throw(422, '手机号或密码错误');
    }

    // 生成包含用户信息的JWT token
    const token = app.jwt.sign({
      person_id: person.person_id,
      person_name: person.person_name,
    }, app.config.jwt.secret);

    // 返回token和用户基本信息
    ctx.body = {
      token,
      person_info: {
        person_id: person.person_id,
        person_name: person.person_name,
        role_main: person.role_main,
        role: person.role,
        role_destination: person.role_destination,
        role_ov: person.role_ov,
      },
    };
  }

  // 获取人员投稿统计
  async getContributionStats() {
    const {
      ctx
    } = this;
    ctx.validate({
      person_id: {
        type: 'number',
        required: true
      },
    });

    const {
      person_id
    } = ctx.request.body;
    const stats = await ctx.service.person.getContributionStats(person_id);
    ctx.body = stats;
  }

  /**
   * 获取所有人员的投稿统计信息
   * 支持多维度筛选和排序
   * @param {Object} ctx.request.body
   * @param {string} [ctx.request.body.order_by='score'] - 排序方式：score-按分数，count-按数量
   * @param {string} [ctx.request.body.start_date] - 开始日期，格式：YYYY-MM-DD
   * @param {string} [ctx.request.body.end_date] - 结束日期，格式：YYYY-MM-DD
   * @param {number} [ctx.request.body.project_group_id] - 项目组ID
   * @param {number} [ctx.request.body.department_id] - 部门ID
   * @param {string} [ctx.request.body.person_name] - 人员姓名，模糊匹配
   * @param {number} [ctx.request.body.approved_status] - 审核状态（0:未审核，1:通过，2:驳回）
   * @param {0|1|2} [ctx.request.body.has_platform_submit_date] - 平台提交日期筛选（0:所有, 1:有值, 2:无值）
   */
  async getAllContributionStats() {
    const {
      ctx
    } = this;
    // 验证参数（新增 has_platform_submit_date 验证）
    ctx.validate({
      order_by: {
        type: 'enum',
        values: ['score', 'count'],
        required: false
      },
      start_date: {
        type: 'string',
        required: false,
        format: /^\d{4}-\d{2}-\d{2}$/
      },
      end_date: {
        type: 'string',
        required: false,
        format: /^\d{4}-\d{2}-\d{2}$/
      },
      project_group_id: {
        type: 'number',
        required: false
      },
      department_id: {
        type: 'number',
        required: false
      },
      person_name: {
        type: 'string',
        required: false
      },
      approved_status: {
        type: 'number',
        required: false,
        min: 0,
        max: 2
      },
      // 新增：平台提交日期筛选参数验证
      has_platform_submit_date: {
        type: 'number',
        required: false,
        min: 0,
        max: 2,
        message: 'has_platform_submit_date 必须为 0、1 或 2'
      }
    });

    const stats = await ctx.service.person.getAllPersonContributionStats(ctx.request.body);
    ctx.body = stats;
  }

  /**
   * 修改密码
   * @param {Object} ctx.request.body
   * @param {number} ctx.request.body.person_id - 人员ID
   * @param {string} ctx.request.body.old_password - 旧密码
   * @param {string} ctx.request.body.new_password - 新密码
   * @throws {404} 未找到该人员时抛出异常
   * @throws {422} 旧密码错误时抛出异常
   */
  async changePassword() {
    const {
      ctx
    } = this;
    ctx.validate({
      person_id: {
        type: 'number',
        required: true
      },
      old_password: {
        type: 'string',
        required: true
      },
      new_password: {
        type: 'string',
        required: true
      },
    });

    const result = await ctx.service.person.changePassword(
      ctx.request.body.person_id,
      ctx.request.body.old_password,
      ctx.request.body.new_password
    );

    if (!result) {
      ctx.throw(404, '未找到该人员');
    }
    if (result.error === 'wrong_password') {
      ctx.throw(422, '旧密码错误');
    }

    ctx.body = {
      success: true
    };
  }

  /**
   * 获取所有人员列表
   * 支持按姓名筛选，无需分页
   * @param {Object} ctx.request.body
   * @param {string} [ctx.request.body.person_name] - 人员姓名，模糊匹配
   */
  async getAllList() {
    const {
      ctx
    } = this;

    // 验证参数
    ctx.validate({
      person_name: {
        type: 'string',
        required: false
      },
    }, ctx.request.body);

    const result = await ctx.service.person.findAllWithoutPaging(ctx.request.body);
    ctx.body = result;
  }
  /**
   * 获取所有人员列表
   * 支持按姓名筛选，无需分页
   * @param {Object} ctx.request.body
   * @param {string} [ctx.request.body.person_name] - 人员姓名，模糊匹配
   */
  async getAllList() {
    const {
      ctx
    } = this;

    // 验证参数
    ctx.validate({
      person_name: {
        type: 'string',
        required: false
      },
    }, ctx.request.body);

    const result = await ctx.service.person.findAllWithoutPaging(ctx.request.body);
    ctx.body = result;
  }
  /**
   * 获取所有人员列表 树状 无需分页
   * @param {Object} ctx.request.body
   */
  async getAllListTree() {
    const {
      ctx
    } = this;

    const result = await ctx.service.person.findAllWithoutPagingTree(ctx.request.body);
    ctx.body = result;
  }
}

module.exports = PersonController;